home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1996 January / macformat-033.iso / mac / Shareware City / Developers / VideoToolbox / VideoToolboxSources / ConvolveX.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-27  |  11.2 KB  |  292 lines  |  [TEXT/CWIE]
  1. /* 
  2. ConvolveX/Y.c
  3. © 1989-1993 Denis G. Pelli
  4. Simple one-dimensional convolution. Convolve image in srcBits by array f[] to
  5. produce image dstBits. src and dst may have any pixelSize, but the calculation
  6. itself is done with 8 bits per pixel. Assumes that everything has its origin at
  7. its center. Before calling ConvolveX/Y you should call SetEntries() to set up
  8. the color tables appropriately (unless source and destination pixmaps are both 8
  9. bits/pixel, in which case the color tables are ignored).
  10.  
  11. ConvolveX/Y fills each pixel in the destination with a weighted sum over the
  12. source, centered on the corresponding pixel in the source. To avoid edge
  13. effects, it only computes pixels in the destination which have full support in
  14. the source. If necessary, ConvolveX/Y will inset the source or destination rect,
  15. so that the destination width/height plus the array length equals the source
  16. width/height.
  17.  
  18. It would be nice to convert this to use Get and SetPixelsQuickly instead of
  19. directly accessing the pixels. This would introduce a small overhead, since the
  20. numbers would be copied into a long array and from thence into the pixels, instead
  21. of being stuffed directly, but would probably make this program quite a bit easier
  22. to read.
  23.  
  24. BUGS:
  25. Setting IMPROVED_ROUNDING to true improves results in some applications, but
  26. screws up others (e.g. the demo Filter.c). I don't have time to figure this out at 
  27. the moment, so I'm leaving a flag that can be turned on or off to suit your 
  28. application. I expect to fix this and eliminate the flag in the future.
  29.  
  30. HISTORY:
  31. 4/1/89 dgp    twice as fast, thanks to recoding to use long instead of float arithmetic.
  32. 4/2/89 dgp    made universal by using line buffers for both src and dst, and interfacing
  33.             to the src and dst PixMaps solely through CopyBits.
  34. 4/2/89 dgp    ConvolveX/Y.c, a pre-processor conditional was added to generate ConvolveX
  35.             and ConvolveY from the SAME source. The two files are IDENTICAL except
  36.             for the preprocessor definition of CONVOLVE_X as 1 to generate ConvolveX,
  37.             or 0 to generate ConvolveY.
  38. 10/9/89 dgp    Fixed overflow bug. Speeded up the convolution loop slightly.
  39.             Added conditional to use CopyBitsQuickly instead of CopyBits when source and
  40.             destination pixelSize are 8 bits. This has two virtues. It's faster, and
  41.             it bypasses the Color Manager's transformations through the color and inverse
  42.             color tables, which costs time and loses accuracy.
  43. 10/10/89 dgp Now use RectToAddress to determine the pixelSize of src and dst, to deal
  44.             correctly with window's pixmap.
  45. 7/25/91    dgp    Added explicit preprocessor symbol to turn diagnostic printout on and off.
  46. 8/24/91    dgp    Made compatible with THINK C 5.0.
  47. 8/27/92    dgp    Added Gestalt().
  48. 11/10/92 dgp Now initialize all fields of pixmap, especially the PMVersion.
  49.             Identify all error messages as originating from here: ConvolveX/Y.
  50.             Replaced compile-time conditional by a run-time conditional, so
  51.             that the ConvolveY.c file is no longer needed.
  52. 1/22/93    dgp    SwapMMUMode().
  53. 2/1/93    dgp Improved rounding. Removed calls to Gestalt, as unnecessary overhead.
  54. 2/7/93    dgp    Introduced switch IMPROVED_ROUNDING to disable rounding for debugging.
  55. 2/8/93    dgp Fixed overflow problem caused by the new rounding.
  56. 7/9/93    dgp check for 32-bit addressing capability.
  57. 6/18/94    dgp    can32 is now computed by calling TrapAvailable(_SwapMMUMode), which 
  58.             returns the correct answer even on Macs with dirty ROMs.
  59. 5/23/95 dgp Apple changed the prototype in the header file from SwapMMUMode(char *) to 
  60.             SwapMMUMode(signed char *). To retain compatibility with both old and new
  61.             headers, I cast the argument (void *).
  62. */
  63. #include "VideoToolbox.h"
  64. #ifndef __TRAPS__
  65.     #include <Traps.h>        // _SwapMMUMode
  66. #endif
  67. void ConvolveXY(double f[],int dim,BitMap *srcBits
  68.     ,BitMap *dstBits,Rect *srcRectPtr,Rect *dstRectPtr,int convolveX);
  69. #define DIAGNOSTICS 0        // true or false
  70. #define IMPROVED_ROUNDING 1    // true or false
  71.  
  72. void ConvolveX(double f[],int dim,BitMap *srcBits
  73.     ,BitMap *dstBits,Rect *srcRectPtr,Rect *dstRectPtr)
  74. {
  75.     ConvolveXY(f,dim,srcBits,dstBits,srcRectPtr,dstRectPtr,1);
  76. }
  77.  
  78. void ConvolveY(double f[],int dim,BitMap *srcBits
  79.     ,BitMap *dstBits,Rect *srcRectPtr,Rect *dstRectPtr)
  80. {
  81.     ConvolveXY(f,dim,srcBits,dstBits,srcRectPtr,dstRectPtr,0);
  82. }
  83.  
  84. void ConvolveXY(double f[],int dim,BitMap *srcBits
  85.     ,BitMap *dstBits,Rect *srcRectPtr,Rect *dstRectPtr,int convolveX)
  86. {
  87.     Rect mysrcRect,mydstRect;
  88.     int dstLines,srcLines,dstLength,srcLength;
  89.     int lines;
  90.     unsigned char *dstPtr=NULL;
  91.     register unsigned char *srcPtr=NULL;
  92.     register int i;
  93.     Rect dstRect, srcRect;
  94.     register long t;
  95.     register long *ifun, *fPtr;
  96.     long ifunScale;
  97.     int x,y,srcx,imin,imax;
  98.     double tmax;
  99.     PixMap srcTmp,dstTmp;    /* line buffers */
  100.     #if DIAGNOSTICS
  101.         GDHandle device=NULL;
  102.         double a;
  103.     #endif
  104.     short srcPixelSize,dstPixelSize;
  105.     int error;
  106.     long value;
  107.     signed char mmuMode=true32b;
  108.     Boolean can32;
  109.     
  110.     value=0;
  111.     error=Gestalt(gestaltAddressingModeAttr,&value);
  112.     can32=TrapAvailable(_SwapMMUMode);
  113.     RectToAddress((PixMap *)srcBits,srcRectPtr,NULL,&srcPixelSize,NULL);
  114.     RectToAddress((PixMap *)dstBits,dstRectPtr,NULL,&dstPixelSize,NULL);
  115.     ifun = (long *) malloc(dim*sizeof(*ifun));
  116.     if(ifun == NULL) {
  117.         PrintfExit("ConvolveX/Y: Sorry, couldn't allocate enough memory for working array\007\n");
  118.     }
  119.     /*
  120.     We will sum in a long register.
  121.     The sum over the point spread function f[] will yield at most tmax, defined below,
  122.     so we can safely multiply f[] by LONG_MAX/tmax, without danger of overflowing t.
  123.     */
  124.     for (tmax=0.0, i=0;i<dim;i++) tmax += fabs(f[i]);
  125.     tmax *= UCHAR_MAX+1;    /* maximum value for a pixel, 255, plus 1 for rounding */
  126.     if(tmax<1.0)tmax=1.0;
  127.     ifunScale = LONG_MAX/tmax;
  128.     for (i=0;i<dim;i++) ifun[i] = f[i]*ifunScale;
  129.     
  130.     #if DIAGNOSTICS
  131.         /* This is a diagnostic printout to track down overflow problems */
  132.         t = 0L;
  133.         a = 0.0;
  134.         for (i=0;i<dim;i++) {
  135.             t += labs(UCHAR_MAX*ifun[i]);
  136.             a += fabs(f[i]);
  137.         }
  138.         device=GetGDevice();
  139.         SetGDevice(GetMainDevice());
  140.         PmForeColor(UCHAR_MAX);
  141.         PmBackColor(0);
  142.         PrintfExit("a=%lf, t=%lx, ifunScale=%lx, t/ifunScale=%lf\n",a,t,ifunScale,t*1.0/ifunScale);
  143.         SetGDevice(device);
  144.     #endif
  145.     
  146.     /*
  147.     Unfortunately CopyBits will crash if the line buffer is too large, e.g.
  148.     640 pixels long. We can minimize this problem by reducing the size of the
  149.     srcRect to be no larger than necessary (i.e. dstRect plus dim).
  150.     */
  151.     mysrcRect = *srcRectPtr;
  152.     mydstRect = *dstRectPtr;
  153.     if(convolveX){
  154.         i=mysrcRect.right-mysrcRect.left - (dim+mydstRect.right-mydstRect.left);
  155.         if(i>0)InsetRect(&mysrcRect,i/2,0);
  156.         i=mysrcRect.bottom-mysrcRect.top - (mydstRect.bottom-mydstRect.top);
  157.         if(i>0)InsetRect(&mysrcRect,0,i/2);
  158.         if(i<0)InsetRect(&mydstRect,0,-i/2);
  159.     }else{
  160.         i=mysrcRect.right-mysrcRect.left - (mydstRect.right-mydstRect.left);
  161.         if(i>0)InsetRect(&mysrcRect,i/2,0);
  162.         if(i<0)InsetRect(&mydstRect,-i/2,0);
  163.         i=mysrcRect.bottom-mysrcRect.top - (dim+mydstRect.bottom-mydstRect.top);
  164.         if(i>0)InsetRect(&mysrcRect,0,i/2);
  165.     }
  166.     srcRectPtr = &mysrcRect;
  167.     dstRectPtr = &mydstRect;
  168.  
  169.     if(convolveX){
  170.         dstLines = dstRectPtr->bottom-dstRectPtr->top;
  171.         srcLines = srcRectPtr->bottom-srcRectPtr->top;
  172.         dstLength = dstRectPtr->right-dstRectPtr->left;
  173.         srcLength = srcRectPtr->right-srcRectPtr->left;
  174.     }else{
  175.         dstLength = dstRectPtr->bottom-dstRectPtr->top;
  176.         srcLength = srcRectPtr->bottom-srcRectPtr->top;
  177.         dstLines = dstRectPtr->right-dstRectPtr->left;
  178.         srcLines = srcRectPtr->right-srcRectPtr->left;
  179.     }
  180.     if(dstLines > srcLines) lines = srcLines; 
  181.     else lines = dstLines;
  182.     
  183.     /* Allocate our line buffers. */
  184.     srcTmp = **(*GetGDevice())->gdPMap;    /* Use current device to init PixMap fields */
  185.     srcTmp.pmVersion=srcTmp.packType=srcTmp.packSize=0;
  186.     srcTmp.planeBytes=srcTmp.pmReserved=0;
  187.     srcTmp.cmpCount=1;
  188.     srcTmp.pixelSize=8;                    /* The main loop assumes 8 bits per pixel */
  189.     if(convolveX){
  190.         SetRect(&srcTmp.bounds,0,0,srcLength,1);    /* a horizontal line buffer */
  191.     }else{
  192.         SetRect(&srcTmp.bounds,0,0,1,srcLength);    /* a vertical line buffer */
  193.     }
  194.     srcTmp.rowBytes = 2*(((srcTmp.bounds.right-srcTmp.bounds.left)*srcTmp.pixelSize+15)/16);
  195.     srcTmp.baseAddr = (Ptr) malloc(srcTmp.rowBytes*(srcTmp.bounds.bottom-srcTmp.bounds.top));
  196.     srcTmp.rowBytes |= 0x8000;    /* Mark it as a PixMap, not a BitMap */
  197.     dstTmp = srcTmp;
  198.     if(convolveX){
  199.         SetRect(&dstTmp.bounds,0,0,dstLength,1);    /* a horizontal line buffer */
  200.     }else{
  201.         SetRect(&dstTmp.bounds,0,0,1,dstLength);    /* a vertical line buffer */
  202.     }
  203.     dstTmp.rowBytes = 2*(((dstTmp.bounds.right-dstTmp.bounds.left)*dstTmp.pixelSize+15)/16);
  204.     dstTmp.baseAddr = (Ptr) malloc(dstTmp.rowBytes*(dstTmp.bounds.bottom-dstTmp.bounds.top));
  205.     dstTmp.rowBytes |= 0x8000;    /* Mark it as a PixMap, not a BitMap */
  206.     if(srcTmp.baseAddr == NULL || dstTmp.baseAddr == NULL)
  207.         PrintfExit("ConvolveX/Y: Sorry, couldn't allocate enough memory for working arrays\007\n");
  208.     
  209.     /* Define the rectangles that map src and dst to their respective line buffers */
  210.     srcRect = srcTmp.bounds;
  211.     OffsetRect(&srcRect,srcRectPtr->left,srcRectPtr->top);
  212.     dstRect = dstTmp.bounds;
  213.     OffsetRect(&dstRect,dstRectPtr->left,dstRectPtr->top);
  214.     if(convolveX){
  215.         OffsetRect(&srcRect,0,srcLines/2-lines/2);
  216.         OffsetRect(&dstRect,0,dstLines/2-lines/2);
  217.     }else{
  218.         OffsetRect(&srcRect,srcLines/2-lines/2,0);
  219.         OffsetRect(&dstRect,dstLines/2-lines/2,0);
  220.     }
  221.     
  222.     /* Convolve one line per iteration */
  223.     /* y indicates which line, x indicates which pixel along that line */
  224.     for (y= -lines/2; y<(lines+1)/2; y++) {
  225.         /* first copy a line from srcBits into line-buffer srcTmp */
  226.         if(srcPixelSize == srcTmp.pixelSize)
  227.             CopyBitsQuickly(srcBits,(BitMap *) &srcTmp,&srcRect,&srcTmp.bounds,srcCopy,NULL);
  228.         else
  229.             CopyBits(srcBits,(BitMap *) &srcTmp,&srcRect,&srcTmp.bounds,srcCopy,NULL);
  230.         if(can32)SwapMMUMode((void *)&mmuMode);
  231.         if(!convolveX){
  232.             /* Unfortunately the minimum PixMap rowBytes is 2 bytes, so we
  233.             squeeze out the extra space before processing
  234.             */
  235.             srcPtr= (unsigned char *) srcTmp.baseAddr;
  236.             dstPtr= (unsigned char *) srcTmp.baseAddr;
  237.             for (x=0; x<srcLength; x++) {
  238.                 *dstPtr++ = *srcPtr;
  239.                 srcPtr += 2;
  240.             }
  241.         }
  242.         dstPtr= (unsigned char *) dstTmp.baseAddr;
  243.         srcx = srcLength/2 - dim/2 - dstLength/2;
  244.         for (x=0; x<dstLength; x++) {
  245.             imax=dim;
  246.             if(srcx+dim>srcLength) imax=srcLength-srcx;
  247.             if(srcx<0){
  248.                 imin= -srcx;
  249.                 srcPtr=(unsigned char *) srcTmp.baseAddr;
  250.             }
  251.             else {
  252.                 imin=0;
  253.                 srcPtr=(unsigned char *) srcTmp.baseAddr+srcx;
  254.             }
  255.             fPtr=&ifun[imin];
  256.             for (t=0L, i=imin;i<imax;i++) t += *fPtr++ * (long)(unsigned long) *srcPtr++;
  257. #if IMPROVED_ROUNDING
  258.             if(t>0)t+=ifunScale>>1;        // round t/ifunScale to nearest integer
  259.             else t-=ifunScale>>1;
  260. #endif
  261.             t/=ifunScale;
  262.             if(convolveX){
  263.                 *dstPtr++ = (unsigned char) t;
  264.             }else{
  265.                 /* Unfortunately the minimum PixMap rowBytes is 2 bytes, so we
  266.                 insert a space between pixels
  267.                 */
  268.                 *dstPtr = (unsigned char) t;
  269.                 dstPtr += 2;
  270.             }
  271.             srcx++;
  272.         }
  273.         if(can32)SwapMMUMode((void *)&mmuMode);
  274.         /* finally, copy the line from buffer dstTmp to dstBits */
  275.         if(dstPixelSize == dstTmp.pixelSize)
  276.             CopyBitsQuickly((BitMap *) &dstTmp,dstBits,&dstTmp.bounds,&dstRect,srcCopy,NULL);
  277.         else
  278.             CopyBits((BitMap *) &dstTmp,dstBits,&dstTmp.bounds,&dstRect,srcCopy,NULL);
  279.         if(convolveX){
  280.             OffsetRect(&srcRect,0,1);    /* adjust Rects to point to next line */
  281.             OffsetRect(&dstRect,0,1);
  282.         }else{
  283.             OffsetRect(&srcRect,1,0);    /* adjust Rects to point to next line */
  284.             OffsetRect(&dstRect,1,0);
  285.         }
  286.     }
  287.     free((void *) ifun);
  288.     free((void *) srcTmp.baseAddr);
  289.     free((void *) dstTmp.baseAddr);
  290. }
  291.  
  292.